package com.ksd.web.controller.service;

import com.ksd.common.utils.uuid.UUID;
import com.ksd.web.controller.process.ProcessStatusEnum;
import com.ksd.web.controller.process.ProcessStep;
import com.ksd.web.controller.process.ProcessVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.concurrent.TimeUnit;

@Service
public class ProcessService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate; // 若用内存缓存则注入InMemoryProcessCache
//    @Autowired
//    private AsyncService asyncService; // 复用之前的AsyncService，或直接用线程池

    // Redis键前缀（避免key冲突）
    private static final String PROCESS_KEY_PREFIX = "channel_config:process:";
    // 任务ID生成器（用UUID确保唯一）
    private String generateProcessId() {
        return UUID.randomUUID().toString().replace("-", "");
    }

    /**
     * 1. 创建任务并初始化状态
     * 2. 提交异步任务执行业务逻辑
     */
    public String createAndStartProcess() {
        // 1. 生成任务ID，初始化任务状态
        String processId = generateProcessId();
        ProcessVO processVO = new ProcessVO();
        processVO.setProcessId(processId);
        processVO.setStatus(ProcessStatusEnum.INIT.getCode());
        processVO.setStatusDesc(ProcessStatusEnum.INIT.getDesc());
        processVO.setSteps(new ArrayList<>());
        processVO.setLatestStep(new ProcessStep(getCurrentTime(), "任务初始化", "一键配置任务已启动，开始处理板卡数据"));

        // 2. 存入缓存（Redis/内存）
        redisTemplate.opsForValue().set(PROCESS_KEY_PREFIX + processId, processVO, 30, TimeUnit.MINUTES); // Redis：30分钟过期
        // inMemoryProcessCache.put(processId, processVO); // 内存缓存

        // 3. 提交异步任务执行核心业务逻辑（复用asyncClearAgainScanExecutor线程池）
//        asyncService.executeConfigProcess(processId);

        // 4. 返回任务ID给前端（前端用此ID查询状态）
        return processId;
    }

    /**
     * 记录步骤详情（供异步任务调用）
     */
    public void addStep(String processId, String stepName, String stepResult) {
        ProcessStep step = new ProcessStep(getCurrentTime(), stepName, stepResult);
        // Redis更新：先获取原数据，添加步骤后重新存入
        String key = PROCESS_KEY_PREFIX + processId;
        ProcessVO processVO = (ProcessVO) redisTemplate.opsForValue().get(key);
        if (processVO != null) {
            processVO.getSteps().add(step);
            processVO.setLatestStep(step);
            redisTemplate.opsForValue().set(key, processVO, 30, TimeUnit.MINUTES);
        }
        // 内存缓存更新：inMemoryProcessCache.updateStep(processId, step);
    }

    /**
     * 更新任务状态（供异步任务调用）
     */
    public void updateProcessStatus(String processId, ProcessStatusEnum status) {
        String key = PROCESS_KEY_PREFIX + processId;
        ProcessVO processVO = (ProcessVO) redisTemplate.opsForValue().get(key);
        if (processVO != null) {
            processVO.setStatus(status.getCode());
            processVO.setStatusDesc(status.getDesc());
            redisTemplate.opsForValue().set(key, processVO, 30, TimeUnit.MINUTES);
        }
        // 内存缓存更新：inMemoryProcessCache.updateStatus(processId, status);
    }

    /**
     * 查询任务状态（供前端调用）
     */
    public ProcessVO getProcessStatus(String processId) {
        return (ProcessVO) redisTemplate.opsForValue().get(PROCESS_KEY_PREFIX + processId);
        // 内存缓存查询：return inMemoryProcessCache.get(processId);
    }

    // 获取当前时间（格式：yyyy-MM-dd HH:mm:ss）
    private String getCurrentTime() {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    }
}
